import * as $L from "leaflet";
//使用严格模式
"use strict";
// 定义全局变量
var zondyMap = {};   // 创建一个全局变量
zondyMap.default = {};  // 默认参数
// 仓库标记，用于仓库聚合显示
zondyMap.warehouseMarker = new L.MarkerClusterGroup();
// 仓库要素，存储多边形、矩形、圆形仓库
zondyMap.warehouseFeature = new L.FeatureGroup();
zondyMap.activeWarehouse = null; // 激活的仓库图层
zondyMap.warehouseDefaultStyle = { // 仓库默认样式
  stroke: true,
  color: "#CFA58A",
  weight: 2,
  fillOpacity: 1,
  fill: true,
  fillColor: "#FFFFFF",
  fillOpacity: 1,
  radius: 0,
  attribution: ''
};
zondyMap.warehouseHighlightStyle = { // 仓库高亮样式
  stroke: true,
  color: "#CFA58A",
  weight: 4,
  fillOpacity: 1,
  fill: true,
  fillColor: "#FFFFFF",
  fillOpacity: 1,
  attribution: ''
};
zondyMap.warehouseUnits = {}; // 仓库单元数据
zondyMap.unitsLayerGroup = null; // 仓库单元数据
zondyMap.geofencingLayer = null; // 电子围栏
zondyMap.echarts = {
  warehouse: {}, // 仓库数据
  units: {}, // 仓库单元数据
  materials: {}, // 物资统计数据
  type: { // 统计分类
    type: ["生活用品", "救生用品", "医疗用品", "御寒用品"],
    name: ["饼干", "担架", "酒精", "药品", "帐篷", "棉衣", "氧气瓶", "水"],
    use: ["食品", "运送伤员", "救治伤员", "消毒", "居住", "保暖"],
    grade: ["一级", "二级", "三级", "四级", "五级"],
  }
}

/**
 * 点位置计算
 * @param {*} lat1
 * @param {*} long1
 * @param {*} lat2
 * @param {*} long2
 * @param {*} cur
 * @param {*} leng
 * @returns
 */
export function pointPositionCalc(lat1, long1, lat2, long2, cur, leng) {
  return [
    long1 + (long2 - long1) * (cur / leng),
    lat1 + (lat2 - lat1) * (cur / leng),
  ];
}

/**
 * 打开全屏
 * @return {undefined}
 */
export function openFullScreen() {
  // 判断各种浏览器，找到正确的方法
  var requestMethod = document.documentElement.requestFullScreen || //W3C
    document.documentElement.webkitRequestFullScreen || //Chrome等
    document.documentElement.mozRequestFullScreen || //FireFox
    document.documentElement.msRequestFullScreen; //IE11
  if (requestMethod) {
    requestMethod.call(document.documentElement);
  } else if (typeof window.ActiveXObject !== "undefined") {//for IE
    var wscript = new ActiveXObject("WScript.Shell");
    if (wscript !== null) {
      wscript.SendKeys("{F11}");
    }
  }
}

/**
 * 退出全屏
 * @return {undefined}
 */
export function exitFull() {
  // 判断各种浏览器，找到正确的方法
  var exitMethod = document.exitFullscreen || //W3C
    document.mozCancelFullScreen || //Chrome等
    document.webkitExitFullscreen || //FireFox
    document.webkitExitFullscreen; //IE11
  if (exitMethod) {
    exitMethod.call(document);
  } else if (typeof window.ActiveXObject !== "undefined") {//for Internet Explorer
    var wscript = new ActiveXObject("WScript.Shell");
    if (wscript !== null) {
      wscript.SendKeys("{F11}");
    }
  }
}

/**
 * 获取当前时间（如："2018-07-17 09:40:17"）
 */
export function getCurentTime() {
  var now = new Date();
  //获取当前年份
  var year = now.getFullYear();
  //获取当前月份
  var month = now.getMonth() + 1;
  //获取当前日期
  var day = now.getDate();
  //获取当前时刻
  var hh = now.getHours();
  //获取当前分钟
  var mm = now.getMinutes();
  //获取当前秒钟
  var ss = now.getSeconds();
  //将当前的日期拼串
  var clock = year + "-";
  if (month < 10)
    clock += "0";
  clock += month + "-";
  if (day < 10)
    clock += "0";
  clock += day + " ";
  if (hh < 10)
    clock += "0";
  clock += hh + ":";
  if (mm < 10)
    clock += '0';
  clock += mm + ":";
  if (ss < 10)
    clock += '0';
  clock += ss;
  return (clock);
}

/**
 * 通过字符串获取纬经度
 * @param  {String} str 纬经度拼接的字符串
 * @return {Array}      纬经度数组
 */
export function getLatlngByString(str) {
  var arr = [];
  if (str && str !== '') {
    var temp = str.replace(/y/g, 'lat');
    temp = temp.replace(/x/g, 'lng');
    arr = JSON.parse(temp);
  }
  return arr;
}


/**
 * 通过纬经度获取字符串
 * @param  {Array}  latlng 纬经度数组
 * @return {String}        纬经度拼接的字符串
 */
export function getStringByLatlng(latlng) {
  var str = '';
  if (!!latlng) {
    var temp = JSON.stringify(latlng);
    temp = temp.replace(/lat/g, "y");
    temp = temp.replace(/lng/g, "x");
    str = temp;
  }
  return str;
}

/**
 * 判断点是否在圆内(含圆上)
 * @param  {L.latLng}  point        点，纬度和经度的地理点
 * @param  {L.latLng}  circleCenter 圆心，纬度和经度的地理点
 * @param  {Number}    radius       圆的半径，米为单位
 * @return {Boolean}                true表示点在圆内或圆上，false表示点在圆外
 */
export function isPointInCircle(point, circleCenter, radius) {
  if (point instanceof L.LatLng && circleCenter instanceof L.LatLng && radius > 0) {
    var distance = map.distance(point, circleCenter);
    if (distance > radius) {
      return false;
    } else {
      return true;
    }
  } else {
    console.warn("参数错误，请检查！");
  }
}

/**
 * 判断2个圆形是否相交
 * @param  {L.Circle}  cir1 圆形图层
 * @param  {L.Circle}  cir2 圆形图层
 * @return {Boolean}        true表示相交，false表示不相交
 */
export function isCircleIntersect(cir1, cir2) {
  if (cir1 instanceof L.Circle && cir2 instanceof L.Circle) {
    var cir1Center = cir1.getLatLng();
    var cir1Radius = cir1.getRadius();
    var cir2Center = cir2.getLatLng();
    var cir2Radius = cir2.getRadius();
    var distance = L.CRS.EPSG3857.distance(cir1Center, cir2Center);
    if (distance <= cir1Radius + cir2Radius) {
      return true;
    }
  } else {
    throw new Error('参数错误，请检查！');
  }
  return false;
}

/**
 * 几何体包含判断(不包括多多边形与带洞的多边形)：判断源几何是否包含目标几何
 * @param   {L.Polygon|L.Rectangle|L.Circle} src  源几何
 * @param   {L.Polygon|L.Rectangle|L.Circle} dest 目标几何
 * @returns {Boolean} true表示包含，false表示不包含
 */
export function isGeomContainGeom(src, dest) {
  if (src instanceof L.Polygon || src instanceof L.Rectangle) {
    if (dest instanceof L.Polygon || dest instanceof L.Rectangle) {
      // 1、多边形与多边形的包含关系，dest多边形的任意一个顶点都在src多边形内部
      var destLatLngs = dest.getLatLngs();
      for (var i = destLatLngs.length - 1; i >= 0; i--) {
        for (var j = destLatLngs[i].length - 1; j >= 0; j--) {
          var point = turf.point([destLatLngs[i][j].lng, destLatLngs[i][j].lat]);
          if (!turf.booleanPointInPolygon(point, src.toGeoJSON())) {
            return false;
          }
        }
      }
    } else if (dest instanceof L.Circle) {
      // 2、多边形与圆的包含关系，满足2个条件：①圆心在多边形内部；②圆心距多边形的任意一条边的最短距离大于圆的半径。
      var radius = dest.getRadius();
      var latlngs = src.getLatLngs();
      if (!turf.booleanPointInPolygon(dest.toGeoJSON(), src.toGeoJSON())) {
        return false;
      }
      for (var i = latlngs.length - 1; i >= 0; i--) {
        for (var j = latlngs[i].length - 1; j >= 0; j--) {
          var polyline;
          if (j == 0) {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][latlngs[i].length - 1].lat, latlngs[i][latlngs[i].length - 1].lng]]);
          } else {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][j - 1].lat, latlngs[i][j - 1].lng]]);
          }
          var distance = turf.pointToLineDistance(dest.toGeoJSON(), polyline.toGeoJSON(), {units: 'meters',mercator: false});
          if (distance <= radius) {
            return false;
          }
        }
      }
    } else {
      throw new Error("目标几何类型不是多边形、矩形、圆形");
    }
  } else if (src instanceof L.Circle) {
    if (dest instanceof L.Polygon || dest instanceof L.Rectangle) {
      // 3、圆与多边形的包含关系，满足一个条件：多边形的顶点都在圆内
      var center = src.getLatLng();
      var radius = src.getRadius();
      var latlngs = dest.getLatLngs();
      for (var i = latlngs.length - 1; i >= 0; i--) {
        for (var j = latlngs[i].length - 1; j >= 0; j--) {
          var distance = L.CRS.EPSG3857.distance(latlngs[i][j], center);
          if (distance > radius) {
            return false;
          }
        }
      }
    } else if (dest instanceof L.Circle) {
      // 4、圆与圆的包含关系
      /**
       * （1）d>R+r   两圆外离；两圆的圆心距离之和大于两圆的半径之和。
       * （2）d=R+r   两圆外切；两圆的圆心距离之和等于两圆的半径之和。
       * （3）d=R-r   两圆内切；两圆的圆心距离之和等于两圆的半径之差。
       * （4）d<R-r   两圆内含；两圆的圆心距离之和小于两圆的半径之差。
       * （5）d<R+r   两园相交；两圆的圆心距离之和小于两圆的半径之和。
       */
      var srcCenter = src.getLatLng();
      var srcRadius = src.getRadius();
      var destCenter = dest.getLatLng();
      var destRadius = dest.getRadius();
      // 判断2个圆心距离小于等于源几何的半径，否则返回false
      var distance = L.CRS.EPSG3857.distance(srcCenter, destCenter);
      if (distance > Math.abs(srcRadius - destRadius)) {
        return false;
      }
    } else {
      throw new Error("目标几何类型不是多边形、矩形、圆形");
    }
  } else {
    throw new Error("源几何类型不是多边形、矩形、圆形");
  }
  return true;
}

/**
 * 几何体相离判断(不包括多多边形与带洞的多边形)：判断源几何是否与目标几何相离
 * @param {L.Polygon|L.Rectangle|L.Circle} src 源几何
 * @param {L.Polygon|L.Rectangle|L.Circle} dest 目标几何
 * @returns {Boolean}  true表示相离，false表示不相离
 */
export function isGeomSeparateGeom(src, dest){
  if (src instanceof L.Polygon || src instanceof L.Rectangle) {
    if (dest instanceof L.Polygon || dest instanceof L.Rectangle) {
      // 1、判断多边形与多边形是否相离，满足2个条件：①src多边形的顶点不在dest多边形内部；②dest多边形的顶点不在src多边形内部。
      var srcLatLngs = src.getLatLngs();
      var destLatLngs = dest.getLatLngs();
      for (var i = srcLatLngs.length - 1; i >= 0; i--) {
        for (var j = srcLatLngs[i].length - 1; j >= 0; j--) {
          var point = turf.point([srcLatLngs[i][j].lng, srcLatLngs[i][j].lat]);
          if (turf.booleanPointInPolygon(point, dest.toGeoJSON())) {
            return false;
          }
        }
      }
      for (var i = destLatLngs.length - 1; i >= 0; i--) {
        for (var j = destLatLngs[i].length - 1; j >= 0; j--) {
          var point = turf.point([destLatLngs[i][j].lng, destLatLngs[i][j].lat]);
          if (turf.booleanPointInPolygon(point, src.toGeoJSON())) {
            return false;
          }
        }
      }
    } else if (dest instanceof L.Circle) {
      // 2、判断多边形与圆是否相离，满足2个条件：①圆心不在多边形内部；②圆心距多边形任意一条边的最短距离大于圆半径
      if (turf.booleanPointInPolygon(dest.toGeoJSON(), src.toGeoJSON())) {
        return false;
      }
      var radius = dest.getRadius();
      var latlngs = src.getLatLngs();
      for (var i = latlngs.length - 1; i >= 0; i--) {
        for (var j = latlngs[i].length - 1; j >= 0; j--) {
          var polyline;
          if (j == 0) {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][latlngs[i].length - 1].lat, latlngs[i][latlngs[i].length - 1].lng]]);
          } else {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][j - 1].lat, latlngs[i][j - 1].lng]]);
          }
          var distance = turf.pointToLineDistance(dest.toGeoJSON(), polyline.toGeoJSON(), {units: 'meters',mercator: false});
          if (distance <= radius) {
            return false;
          }
        }
      }
    } else {
      throw new Error("目标几何类型不是多边形、矩形、圆形");
    }
  } else if (src instanceof L.Circle) {
    if (dest instanceof L.Polygon || dest instanceof L.Rectangle) {
      // 3、判断圆与多边形是否相离，满足2个条件：①圆心不在多边形内部；②圆心距多边形任意一条边的最短距离大于圆半径
      if (turf.booleanPointInPolygon(src.toGeoJSON(), dest.toGeoJSON())) {
        return false;
      }
      var radius = src.getRadius();
      var latlngs = dest.getLatLngs();
      for (var i = latlngs.length - 1; i >= 0; i--) {
        for (var j = latlngs[i].length - 1; j >= 0; j--) {
          var polyline;
          if (j == 0) {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][latlngs[i].length - 1].lat, latlngs[i][latlngs[i].length - 1].lng]]);
          } else {
            polyline = L.polyline([[latlngs[i][j].lat, latlngs[i][j].lng], [latlngs[i][j - 1].lat, latlngs[i][j - 1].lng]]);
          }
          var distance = turf.pointToLineDistance(src.toGeoJSON(), polyline.toGeoJSON(), {units: 'meters',mercator: false});
          if (distance <= radius) {
            return false;
          }
        }
      }
    } else if (dest instanceof L.Circle) {
      // 4、判断圆与圆是否相离，满足1个条件：两圆的圆心距离之和大于两圆的半径之和。
      var srcCenter = src.getLatLng();
      var srcRadius = src.getRadius();
      var destCenter = dest.getLatLng();
      var destRadius = dest.getRadius();
      var distance = L.CRS.EPSG3857.distance(srcCenter, destCenter);
      if (distance <= srcRadius + destRadius) {
        return false;
      }
    } else {
      throw new Error("目标几何类型不是多边形、矩形、圆形");
    }
  } else {
    throw new Error("源几何类型不是多边形、矩形、圆形");
  }
  return true;
}

/**
 * 小数保留多少位设置
 * @param  {Number} num 小数
 * @param  {Number} len 小数保留位数
 * @return {Number}     保留指定小数位的数字
 */
export function round(num, len) {
  return Math.round(num * (Math.pow(10, len))) / (Math.pow(10, len));
};

/**
 * 转换经纬度格式为 (x.xxxxxx, y.yyyyyy)
 * @param  {L.LatLng} latlng 纬经度
 * @return {String}  (x, y)格式的字符串
 */
export function strLatLng(latlng) {
  return "(" + round(latlng.lat, 6) + ", " + round(latlng.lng, 6) + ")";
};

/**
 * 弹出框内容，内容为几何图层的面积、距离、坐标
 * @param  {L.Marker|L.CircleMarker|L.Circle|L.Polygon|L.Polyline} layer 几何图层
 * @return {String|null}    面积、距离、坐标的字符串
 */
export function getPopupContent(layer) {
  // 标注 - 纬度/经度
  if (layer instanceof L.Marker || layer instanceof L.CircleMarker) {
    return strLatLng(layer.getLatLng());
    // 圆 - 纬度/经度, 半径
  } else if (layer instanceof L.Circle) {
    var center = layer.getLatLng(),
      radius = layer.getRadius();
    return "Center: " + strLatLng(center) + "<br />"
      + "Radius: " + round(radius, 2) + " m";
    // 矩形/多边形 - 面积
  } else if (layer instanceof L.Polygon) {
    var latlngs = layer._defaultShape ? layer._defaultShape() : layer.getLatLngs(),
      area = L.GeometryUtil.geodesicArea(latlngs);
    return "面积: " + L.GeometryUtil.readableArea(area, ['km', 'm'], { km: 2, ha: 2, m: 2, mi: 2, ac: 2, yd: 0, ft: 0, nm: 2 });
    // return "面积: "+L.GeometryUtil.readableArea(area, 'm', {km: 2, ha: 2, m: 2, mi: 2, ac: 2, yd: 0, ft: 0, nm: 2});
    // 折线 - 距离
  } else if (layer instanceof L.Polyline) {
    var latlngs = layer._defaultShape ? layer._defaultShape() : layer.getLatLngs(),
      distance = 0;
    if (latlngs.length < 2) {
      return "距离: N/A";
    } else {
      for (var i = 0; i < latlngs.length - 1; i++) {
        distance += latlngs[i].distanceTo(latlngs[i + 1]);
      }
      return "距离: " + round(distance, 2) + " m";
    }
  }
  return null;
};


/**
 * 设置绘制围栏工具条的提示
 */
export function setDrawGeofencingToolTip() {
  L.drawLocal = {
    draw: {
      toolbar: {
        actions: {
          title: '取消绘制围栏',
          text: '取消'
        },
        finish: {
          title: '完成绘制围栏',
          text: '完成'
        },
        undo: {
          title: '删除最后绘制围栏的点',
          text: '删除最后一点'
        },
        buttons: {
          polyline: '绘制折线围栏',
          polygon: '绘制多边形围栏',
          rectangle: '绘制一个矩形围栏',
          circle: '绘制一个圆形围栏',
          marker: '绘制一个标记',
          circlemarker: '绘制一个圆圈标记'
        }
      },
      handlers: {
        circle: {
          tooltip: {
            start: '单击并拖动绘制圆形围栏'
          },
          radius: '围栏半径'
        },
        circlemarker: {
          tooltip: {
            start: '单击地图以放置圆形标记'
          }
        },
        marker: {
          tooltip: {
            start: '单击地图以放置标记'
          }
        },
        polygon: {
          tooltip: {
            start: '单击开始绘制多边形围栏',
            cont: '单击继续绘制多边形围栏',
            end: '单击继续绘制多边形围栏，双击结束'
          }
        },
        polyline: {
          error: '<strong>出错:</strong> 边缘不能交叉!',
          tooltip: {
            start: '单击开始画线',
            cont: '单击继续画线',
            end: '单击最后一点到完成画线'
          }
        },
        rectangle: {
          tooltip: {
            start: '单击并拖动绘制矩形围栏'
          }
        },
        simpleshape: {
          tooltip: {
            end: '松开鼠标完成绘制围栏'
          }
        }
      }
    },
    edit: {
      toolbar: {
        actions: {
          save: {
            title: '保存更改围栏',
            text: '保存'
          },
          cancel: {
            title: '取消编辑围栏，放弃所有更改',
            text: '取消'
          },
          clearAll: {
            title: '清除所有围栏',
            text: '清除所有'
          }
        },
        buttons: {
          edit: '编辑围栏',
          editDisabled: '没有要编辑的围栏',
          remove: '删除围栏',
          removeDisabled: '没有要删除的围栏'
        }
      },
      handlers: {
        edit: {
          tooltip: {
            text: '拖动标记编辑围栏',
            subtext: '单击地图保存'
          }
        },
        remove: {
          tooltip: {
            text: '单击要删除的围栏'
          }
        }
      }
    }
  };
}

/**
 * 设置测量工具条的提示
 */
export function setMeasureToolTip() {
  L.drawLocal = {
    draw: {
      toolbar: {
        actions: {
          title: '取消测量',
          text: '取消'
        },
        finish: {
          title: '完成测量',
          text: '完成'
        },
        undo: {
          title: '删除测量最后的点',
          text: '删除最后一点'
        },
        buttons: {
          polyline: '测量距离',
          polygon: '测量面积',
          rectangle: '测量面积',
          circle: '测量面积',
          marker: '测量面积',
          circlemarker: '测量面积'
        }
      },
      handlers: {
        circle: {
          tooltip: {
            start: '单击并拖动绘制圆形围栏'
          },
          radius: '围栏半径'
        },
        circlemarker: {
          tooltip: {
            start: '单击地图以放置圆形标记'
          }
        },
        marker: {
          tooltip: {
            start: '单击地图以放置标记'
          }
        },
        polygon: {
          tooltip: {
            start: '单击开始绘制多边形',
            cont: '单击继续绘制, 双击完成绘制',
            end: '双击完成绘制'
          }
        },
        rectangle: {
          tooltip: {
            start: '单击并拖动以测量面积'
          }
        },
        polyline: {
          error: '<strong>出错:</strong> 边缘不能交叉!',
          tooltip: {
            start: '单击开始画线',
            cont: '单击继续画线',
            end: '单击继续画线, 双击完成画线'
          }
        },
        simpleshape: {
          tooltip: {
            end: '释放鼠标以完成测量'
          }
        }
      }
    },
    edit: {
      toolbar: {
        actions: {
          save: {
            title: '保存删除后的更改',
            text: '保存'
          },
          cancel: {
            title: '取消已删除的测量线或面',
            text: '取消'
          },
          clearAll: {
            title: '清除测量线或面',
            text: '清除所有'
          }
        },
        buttons: {
          remove: '删除测量线或面',
          removeDisabled: '没有可删除的测量线或面'
        }
      },
      handlers: {
        edit: {
          tooltip: {
            text: '拖动手柄或标记以编辑测量线或面',
            subtext: '单击取消以撤消更改'
          }
        },
        remove: {
          tooltip: {
            text: '单击要删除的测量线或面'
          }
        }
      }
    }
  };
}

/**
 * 设置绘制取坐标工具条的提示
 */
export function setDrawlatlngToolTip() {
  L.drawLocal = {
    draw: {
      toolbar: {
        actions: {
          title: '取消绘制',
          text: '取消'
        },
        finish: {
          title: '完成绘制',
          text: '完成'
        },
        undo: {
          title: '删除最后绘制的点',
          text: '删除最后一点'
        },
        buttons: {
          polyline: '绘制折线取坐标',
          polygon: '绘制多边形取坐标',
          rectangle: '绘制一个矩形取坐标',
          circle: '绘制一个圆形取坐标',
          marker: '绘制一个标记取坐标',
          circlemarker: '绘制一个圆圈标记'
        }
      },
      handlers: {
        circle: {
          tooltip: {
            start: '单击并拖动绘制圆形'
          },
          radius: '半径'
        },
        circlemarker: {
          tooltip: {
            start: '单击地图以放置圆形标记'
          }
        },
        marker: {
          tooltip: {
            start: '单击地图以放置标记'
          }
        },
        polygon: {
          tooltip: {
            start: '单击开始绘制多边形',
            cont: '单击继续绘制多边形',
            end: '单击继续绘制多边形，双击结束'
          }
        },
        polyline: {
          error: '<strong>出错:</strong> 边缘不能交叉!',
          tooltip: {
            start: '单击开始画线',
            cont: '单击继续画线',
            end: '单击最后一点到完成画线'
          }
        },
        rectangle: {
          tooltip: {
            start: '单击并拖动绘制矩形'
          }
        },
        marker: {
          tooltip: {
            start: '单击绘制点'
          }
        },
        simpleshape: {
          tooltip: {
            end: '松开鼠标完成绘制'
          }
        }
      }
    },
    edit: {
      toolbar: {
        actions: {
          save: {
            title: '保存更改',
            text: '保存'
          },
          cancel: {
            title: '取消编辑，放弃所有更改',
            text: '取消'
          },
          clearAll: {
            title: '清除所有',
            text: '清除所有'
          }
        },
        buttons: {
          edit: '编辑',
          editDisabled: '没有要编辑的',
          remove: '删除',
          removeDisabled: '没有要删除的'
        }
      },
      handlers: {
        edit: {
          tooltip: {
            text: '拖动标记编辑',
            subtext: '单击地图保存'
          }
        },
        remove: {
          tooltip: {
            text: '单击要删除的'
          }
        }
      }
    }
  };
}


/**
 * 设置绘制工具条的提示
 */
export function setDrawToolTip() {
  L.drawLocal = {
    draw: {
      toolbar: {
        actions: {
          title: '取消绘制',
          text: '取消'
        },
        finish: {
          title: '完成绘制',
          text: '完成'
        },
        undo: {
          title: '删除最后绘制的点',
          text: '删除最后一点'
        },
        buttons: {
          polyline: '绘制折线',
          polygon: '绘制多边形',
          rectangle: '绘制一个矩形',
          circle: '绘制一个圆形',
          marker: '绘制一个标记',
          circlemarker: '绘制一个圆圈标记'
        }
      },
      handlers: {
        circle: {
          tooltip: {
            start: '单击并拖动绘制圆形'
          },
          radius: '半径'
        },
        circlemarker: {
          tooltip: {
            start: '单击地图放置圆形标记'
          }
        },
        marker: {
          tooltip: {
            start: '单击地图放置标记'
          }
        },
        polygon: {
          tooltip: {
            start: '单击开始绘制多边形',
            cont: '单击继续绘制多边形',
            end: '单击继续绘制多边形，双击结束'
          }
        },
        polyline: {
          error: '<strong>出错:</strong> 边缘不能交叉!',
          tooltip: {
            start: '单击开始画线',
            cont: '单击继续画线',
            end: '单击最后一点到完成画线'
          }
        },
        rectangle: {
          tooltip: {
            start: '单击并拖动绘制矩形'
          }
        },
        simpleshape: {
          tooltip: {
            end: '松开鼠标完成绘制'
          }
        }
      }
    },
    edit: {
      toolbar: {
        actions: {
          save: {
            title: '保存更改',
            text: '保存'
          },
          cancel: {
            title: '取消编辑，放弃所有更改',
            text: '取消'
          },
          clearAll: {
            title: '清除所有',
            text: '清除所有'
          }
        },
        buttons: {
          edit: '编辑图层',
          editDisabled: '没有要编辑的图层',
          remove: '删除图层',
          removeDisabled: '没有要删除的图层'
        }
      },
      handlers: {
        edit: {
          tooltip: {
            text: '拖动标记编辑图层',
            subtext: '单击地图保存'
          }
        },
        remove: {
          tooltip: {
            text: '单击要删除的图层'
          }
        }
      }
    }
  };
}

/**
 * 测试添加轨迹点
 */
function TestAddMaterialsTrack(){
  //添加绘制图层
  var drawnItems = new L.FeatureGroup();
  map.addLayer(drawnItems);
  //添加绘制控件
  var drawControl = new L.Control.Draw({
    position: 'topleft',
    draw: {
      //绘制矩形
      rectangle: true
      //绘制圆
      ,circle: true
      //绘制线
      ,polyline: true
      //绘制多边形
      ,polygon: {
        // 不允许多边形不相邻边相交
        allowIntersection: false,
        // 是否在工具提示中显示面积
        showArea: true
      }
      //绘制标注
      ,marker: true
      //绘制圆形标注
      ,circlemarker: true
    },
    edit: {
      //绘制图层
      featureGroup: drawnItems,
      //图形编辑控件
      edit: true,
      //图形删除控件
      remove: true,
      poly: false,
      allowIntersection: false
    }
  });
  //添加绘制控件
  map.addControl(drawControl);

  //绘制完成事件-保存
  map.on(L.Draw.Event.CREATED, function (e) {
    //获取绘制图形类型
    var type = e.layerType,
      //获取绘制图层
      drawlayer = e.layer;
    if (type == "marker") {
      var lnglat = drawlayer.getLatLng();
      var params = {id: "bd727ba2-6253-4775-880f-60ce05fccfaa", time: getCurentTime(),coordsX: lnglat.lng, coordsY: lnglat.lat};
      commonPostAjax("../Handler.ashx?action=TestAddMaterialsTrack", params, function(data){
        if (data.code === "1") {
          showMsg("添加一个轨迹点成功");
        }
      });
    }
  });
}
